
%reset # Reset variables

# Data Science Packages
import numpy as np
import pandas as pd

# Visualization Packages
import plotly.express as px

# Statistics Packages
import statsmodels.api as sm
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, accuracy_score

# For exporting plotly graphs to HTML
import plotly.io as pio
pio.renderers.default='notebook'


# Read in the data from csv, and import it to a pandas dataframe
df = pd.read_csv('lol_ranked_games.csv') # Ref (1)

print(df.isnull().any().any()) # Double check there are no null values

# The data consists of tie 'frames' within the game. Since time is not considered in the analysis,
# only consider the last row of each game by using the groupby() method to group by the gameID,
# use the .last() method to take the final time frame of the game, and reset the index for consistency
df_clean = df.groupby('gameId').last().reset_index() # Remove the temporal aspect from the data and reset the index

df_describe = df_clean.describe() # Describe the statistics to look for outliers

False


fig = px.histogram(df_clean['wardsPlaced'])
fig.update_layout(title='Wards Placed Histogram', xaxis_title='Wards Placed')
fig.show()

print('The number of wards placed greater than 400 is ' + str(sum(df_clean['wardsPlaced']>400)))

The number of wards placed greater than 400 is 248


# Drop Nexus Turrets since they are irrelevant to the analysis
df_clean=df_clean.drop(columns=['lostTopBaseTurret', 'lostMidBaseTurret', 'lostBotBaseTurret',
    'destroyedTopBaseTurret', 'destroyedMidBaseTurret', 'destroyedBotBaseTurret'])

# Rename nexus turret variables to base turret due to the input error
df_clean=df_clean.rename(columns={'lostTopNexusTurret':'lostTopBaseTurret', 
    'lostMidNexusTurret': 'lostMidBaseTurret', 
    'lostBotNexusTurret': 'lostBotBaseTurret',
    'destroyedTopNexusTurret': 'destroyedTopBaseTurret', 
    'destroyedMidNexusTurret': 'destroyedMidBaseTurret', 
    'destroyedBotNexusTurret': 'destroyedBotBaseTurret'})

# Imputate games where players placed more than 400 wards with the 75% quartile range
# 75% quartile range is used here since 248 total instances <<< 24912 total games, so more complex
# imputation is not necessary
iqr = np.percentile(df_clean['wardsPlaced'], 75)
df_clean['wardsPlaced'][df_clean['wardsPlaced']>400] = iqr

fig = px.histogram(df_clean['wardsPlaced'])
fig.update_layout(title='Wards Placed (Imputated with 75 percentile) Histogram', xaxis_title='Wards Placed')
fig.show()

C:\Users\qmeye\AppData\Local\Temp\ipykernel_4088\59327365.py:17: SettingWithCopyWarning:


A value is trying to be set on a copy of a slice from a DataFrame

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy


corr = df_clean.corr() # Correlation Matrix
corr = corr[corr>0.8] # Look for highly correlated variables in the data set

# How to deal with correlated variables:
# frame correlates to gameDuration --> Drop frame
# goldDiff, expDiff, championLevelDiff all correlate with one another, and to the dependent variable hasWon -- > drop all 3
# kills correlates to assists --> drop assists

# Drop highly correlated variables since they can interfere with Logistic Regression
df_clean = df_clean.drop(columns=['frame', 'goldDiff', 'expDiff', 'champLevelDiff'])

# Drop irrelevant data
# Kills, assists, and deaths are not key map objectives and are outside the scope of this work
# Wards Placed, wards lost, and wards destroyed are also not key map objectives and are therefore outside scope of this work
# Previous ward imputation work was kept in case the scope of this project ever changes
df_clean = df_clean.drop(columns=['gameId', 'assists', 'kills', 'deaths', 'wardsPlaced', 'wardsLost', 'wardsDestroyed'])

# Drop hasWon and assign to new variable y for train_test_split
y = df_clean['hasWon']
df_clean.drop(columns='hasWon', inplace=True)

# Split training & test data (30% is standard since >10000 variables, random_state for repeatability)
X_train, X_test, y_train, y_test = train_test_split(df_clean, y, test_size=0.3, random_state=42)

X_train = sm.add_constant(X_train) # Add constant for Logistic Regression model
X_test = sm.add_constant(X_test) # Add constant for Logistic Regression model

# The data is now prepared for Logistic Regression analysis --> (X_train, X_test, y_train, y_test)


# Finding Feature Importances using L1 (Lasso) Regularization

# Sklearn's LogisticRegression model is used since it has a L1 Penalty option
# C is the lambda term as seen above, but it implemented inversely, so the smaller the value the more terms will be eliminated
# The optimization solver is liblinear which is robust in the face of large data sets (3)

# Use varying values for c (lambda) to determine an appropriate value based on accuracy
c = [3e-4, 4e-4, 5e-4, 1e-3, 1e-2]

df_c = pd.DataFrame() # allocate memory to append data to

# Loop through Values of vector C to determine the respective accuracy 
for C in c:
    sel_ = LogisticRegression(C=C, penalty='l1', solver = 'liblinear') # Create Logistic Regression object with l1 penalty
    sel_.fit(X_train, y_train) # Fit the model using the X_train and y_train data
    acc = sel_.score(X_test, y_test) # Determine accuracy of the model
    feature_importances_lr = X_train.columns[SelectFromModel(sel_).get_support()] # Determine which features were included in the model given C
    df_c = pd.concat([df_c, pd.DataFrame({'Accuracy': [acc], 
        'Number of Features':[len(feature_importances_lr)], 
        'C':[C]})]) # Report back the accuracy score, number of important features, and C value

fig = px.line(df_c, x='C', y='Accuracy') # Create a line plot figure for C value vs Accuracy

# Loop through every value in df_c so a unique annotation of resulting feature number is added to each point
for i in range(0,len(df_c)):
    if i == 3:
        fig.add_annotation(x=df_c['C'].iloc[i], y=df_c['Accuracy'].iloc[i],
            text='Features: ' + str(df_c['Number of Features'].iloc[i]),
            showarrow=True,
            arrowhead=1,
            yshift=10)
    else:
        fig.add_annotation(x=df_c['C'].iloc[i], y=df_c['Accuracy'].iloc[i],
            text='Features: ' + str(df_c['Number of Features'].iloc[i]),
            showarrow=True,
            arrowhead=1)

fig.update_layout(title='Accuracy vs L1 Penalty (C)') # Create a title
fig.show() # Show the figure


# Extracting important features with the found optimized C value

sel_ = LogisticRegression(C=5e-4, penalty='l1', solver = 'liblinear') # Create Logistic Regression object with l1 penalty
sel_.fit(X_train, y_train) # Fit the model using the X_train and y_train data
feature_importances_lr = X_train.columns[SelectFromModel(sel_).get_support()] # Determine which features were included in the model given C
print(feature_importances_lr) # Print resulting important features

Index(['lostBaronNashor', 'destroyedBotInhibitor', 'lostBotInhibitor',
       'destroyedBotBaseTurret', 'lostBotBaseTurret',
       'destroyedBotInnerTurret', 'lostBotInnerTurret'],
      dtype='object')


# Random Forest Feature Selection

rf = RandomForestClassifier() # Create Random Forest Object
rf.fit(X_train, y_train) # Fit Random Forest to the training data
y_predict = rf.predict(X_test) # Predict whether a team will win or not
print(accuracy_score(y_test, y_predict)) # Print accuracy score

feature_importances_rf = pd.DataFrame(rf.feature_importances_,
    index = X_train.columns,   
    columns=['importance']).sort_values('importance', ascending=False) # Get feature importances from Random Forest

print(feature_importances_rf[0:len(feature_importances_lr)]) # Print the same number of features as chosen from L1 regularization

0.953973775755954
                         importance
destroyedBotBaseTurret     0.109313
lostBotInnerTurret         0.095116
lostBotBaseTurret          0.089524
destroyedBotInnerTurret    0.083337
lostBaronNashor            0.078422
destroyedBotInhibitor      0.070949
lostBotInhibitor           0.058010


df_reduced = df_clean[feature_importances_lr] # Only use features from earlier importance selection

# Split training & test data (30% is standard since 10000 variables, random_state for repeatability)
X_train, X_test, y_train, y_test = train_test_split(df_reduced, y, test_size=0.3, random_state=42)

X_train = sm.add_constant(X_train) # Add constant for model
X_test = sm.add_constant(X_test) # Add constant for model

model_original = sm.Logit(y_train, X_train).fit() # Fit Logistic Regresion Model from Statsmodel
print(model_original.summary()) # Statistical Summary

y_hat = np.round(model_original.predict(X_test)) # Round probabilities for confusion matrix

print('Confusion Matrix \n', confusion_matrix(y_test, y_hat)) # Print confusion matrix to assess any biases
print('Accuracy Score:', accuracy_score(y_test, y_hat)) # Double check accuracy to Sklearn's Logistic Regression model

Optimization terminated successfully.
         Current function value: 0.235927
         Iterations 8
                           Logit Regression Results                           
==============================================================================
Dep. Variable:                 hasWon   No. Observations:                17438
Model:                          Logit   Df Residuals:                    17430
Method:                           MLE   Df Model:                            7
Date:                Sun, 13 Nov 2022   Pseudo R-squ.:                  0.6596
Time:                        14:28:26   Log-Likelihood:                -4114.1
converged:                       True   LL-Null:                       -12087.
Covariance Type:            nonrobust   LLR p-value:                     0.000
===========================================================================================
                              coef    std err          z      P>|z|      [0.025      0.975]
-------------------------------------------------------------------------------------------
const                       0.2269      0.042      5.437      0.000       0.145       0.309
lostBaronNashor            -1.8359      0.057    -32.042      0.000      -1.948      -1.724
destroyedBotInhibitor       1.4924      0.073     20.396      0.000       1.349       1.636
lostBotInhibitor           -0.9134      0.079    -11.599      0.000      -1.068      -0.759
destroyedBotBaseTurret      1.8159      0.084     21.610      0.000       1.651       1.981
lostBotBaseTurret          -1.3285      0.085    -15.626      0.000      -1.495      -1.162
destroyedBotInnerTurret     1.9666      0.066     30.013      0.000       1.838       2.095
lostBotInnerTurret         -1.4112      0.064    -22.196      0.000      -1.536      -1.287
===========================================================================================
Confusion Matrix 
 [[3213  451]
 [ 235 3575]]
Accuracy Score: 0.9082151458389082

League of Legends Analysis¶

Import necessary packages¶

Research Question: Which key map objectives during a game statistically significantly predict the outcome of a ranked game¶

Data Collection¶

Data Extraction and Preparation¶

Analysis¶

Data Summary and Implications¶

Model Explanation:¶

Addressing the Hypothesis:¶

Limitation:¶

Course of Action / Suggestions:¶

Next Steps for Further Studies:¶

Citations:¶